"""
In search.py, you will implement generic search algorithms which are called 
by Pacman agents (in searchAgents.py).
"""

import util

class SearchProblem:
  """
  This class outlines the structure of a search problem, but doesn't implement
  any of the methods (in object-oriented terminology: an abstract class).
  
  You do not need to change anything in this class, ever.
  """
  
  def getStartState(self):
     """
     Returns the start state for the search problem 
     """
     util.raiseNotDefined()
    
  def isGoalState(self, state):
     """
       state: Search state
    
     Returns True if and only if the state is a valid goal state
     """
     util.raiseNotDefined()

  def getSuccessors(self, state):
     """
       state: Search state
     
     For a given state, this should return a list of triples, 
     (successor, action, stepCost), where 'successor' is a 
     successor to the current state, 'action' is the action
     required to get there, and 'stepCost' is the incremental 
     cost of expanding to that successor
     """
     util.raiseNotDefined()

  def getCostOfActions(self, actions):
     """
      actions: A list of actions to take
 
     This method returns the total cost of a particular sequence of actions.  The sequence must
     be composed of legal moves
     """
     util.raiseNotDefined()
           

def tinyMazeSearch(problem):
  """
  Returns a sequence of moves that solves tinyMaze.  For any other
  maze, the sequence of moves will be incorrect, so only use this for tinyMaze
  """
  from game import Directions
  s = Directions.SOUTH
  w = Directions.WEST
  return  [s,s,w,s,w,w,s,w]

class Action:
  "This class is used to keep track of the action"
  def __init__(self, currentState, parentState, totalCost=0):
    self.currentState = currentState
    self.parentState = parentState
    self.totalCost = totalCost
  def getCurrentState(self):
    return self.currentState
  def getParentState(self):
    return self.parentState
  def getTotalCost(self):
    return self.totalCost

def actionSeq(node):
  actSeq = []
  aNode = node
  while aNode.getParentState():
    actSeq.insert(0, aNode.getCurrentState()[1])
    aNode = aNode.getParentState()
  return actSeq
  
def depthFirstSearch(problem):
  """
  Search the deepest nodes in the search tree first [p 74].
  
  Your search algorithm needs to return a list of actions that reaches
  the goal.  Make sure to implement a graph search algorithm [Fig. 3.18].
  
  To get started, you might want to try some of these simple commands to
  understand the search problem that is being passed in:
  
  print "Start:", problem.getStartState()
  print "Is the start a goal?", problem.isGoalState(problem.getStartState())
  print "Start's successors:", problem.getSuccessors(problem.getStartState())
  """
  fringe = util.Stack()
  return searchHelper(problem, fringe)

def breadthFirstSearch(problem):
  "Search the shallowest nodes in the search tree first. [p 74]"
  fringe = util.Queue()
  return searchHelper(problem, fringe)

def searchHelper(problem, fringe):
  """
  The DFS and BFS are different only in how the fringe work
  We can create a general search which accept one more argument which is the fringe
  """
  from game import Directions  
  closed = set([])
  curState = (problem.getStartState(),Directions.STOP,0)
  action = Action(curState, None)
  fringe.push(action)  
  while True:
    if fringe.isEmpty():
      return None
    node = fringe.pop()    
    state = node.getCurrentState()[0]    
    if problem.isGoalState(state):
      return actionSeq(node)
    if state not in closed:
      closed.add(state)
      successors = problem.getSuccessors(state)
      for successor in successors:                   
        fringe.push(Action(successor, node))
  util.raiseNotDefined()
  
def uniformCostSearch(problem):
  "Search the node of least total cost first. "
  from game import Directions
  fringe = util.PriorityQueue()
  closed = set([])
  curState = (problem.getStartState(), Directions.STOP, 0)
  action = Action(curState, None, curState[2])
  fringe.push(action, curState[2])
  while True:
    if (fringe.isEmpty()):
      return None
    node = fringe.pop()
    state = node.getCurrentState()[0]
    if problem.isGoalState(state):
      return actionSeq(node)
    costState = (state, node.getCurrentState()[2])
    if costState not in closed:
      closed.add(costState)
      successors = problem.getSuccessors(state)
      for successor in successors:
        totalCost = node.getTotalCost() + successor[2]
        fringe.push(Action(successor, node, totalCost), totalCost)
  util.raiseNotDefined()

def nullHeuristic(state, problem=None):
  """
  A heuristic function estimates the cost from the current state to the nearest
  goal in the provided SearchProblem.  This heuristic is trivial.
  """
  return 0

def aStarSearch(problem, heuristic=nullHeuristic):
  "Search the node that has the lowest combined cost and heuristic first."
  from game import Directions  
  closed = set([])
  closedDict = {}
  fringe = util.PriorityQueue()
  curState = (problem.getStartState(),Directions.STOP,0)
  action = Action(curState, None, curState[2])
  firstCost = curState[2] + heuristic(curState[0], problem)
  fringe.push(action, firstCost) 
  while True:
    if fringe.isEmpty():
      return None    
    node = fringe.pop()    
    state = node.getCurrentState()[0]    
    if problem.isGoalState(state):
      return actionSeq(node)
    costState = node.getTotalCost()    
    if state not in closed:
      closed.add(state)
      closedDict[state] = costState    
      successors = problem.getSuccessors(state)
      for successor in successors:
        totalCost = node.getTotalCost() + successor[2] + heuristic(successor[0], problem)        
        fringe.push(Action(successor, node, totalCost), totalCost)
    elif costState < closedDict[state]:
      closedDict[state] = costState    
      successors = problem.getSuccessors(state)
      for successor in successors:
        totalCost = node.getTotalCost() + successor[2] + heuristic(successor[0], problem)        
        fringe.push(Action(successor, node, totalCost), totalCost)
  util.raiseNotDefined()
    
  
# Abbreviations
bfs = breadthFirstSearch
dfs = depthFirstSearch
astar = aStarSearch
ucs = uniformCostSearch
